package com.itheima.reggie.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.itheima.reggie.entity.Dish;
import com.itheima.reggie.entity.DishDto;
import com.itheima.reggie.entity.DishFlavor;
import com.itheima.reggie.mapper.DishMapper;
import com.itheima.reggie.service.DishFlavorService;
import com.itheima.reggie.service.DishService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

@Service
@Slf4j
public class DishServiceImpl extends ServiceImpl<DishMapper, Dish> implements DishService {

    @Autowired
    private DishFlavorService dishFlavorService;

    /**
     * 定制新增菜品的方法，可以同时保存菜品口味，以及新增菜品
     * @param dishDto
     */
    @Transactional
    @Override
    public void saveWithFlavor(DishDto dishDto) {

        //先将传入的菜品存入到菜品表中
        //这里直接传入dishDto即可，因为DishDto继承自Dish，mp应该会自动处理
        this.save(dishDto);
        //注意：this.save(dishDto);会自动生成菜品id，并赋值给dishDto中的id属性
        //这里的菜品id不是前端传过来的，而是this.save(dishDto);创建的
        //获取菜品id
        Long id = dishDto.getId();

        //将获取到的dishId赋值给dishFlavor的dishId属性
        List<DishFlavor> dishFlavors = dishDto.getFlavors();

        for (DishFlavor dishFlavor : dishFlavors){
            dishFlavor.setDishId(id);
        }
        //同时将菜品口味数据保存到dish_flavor表
        dishFlavorService.saveBatch(dishFlavors);
    }

    /**
     * 定制同时查询菜品和菜品口味的函数
     * @param id
     * @return
     */
    @Transactional
    @Override
    public DishDto getWithFlavor(Long id) {

        //先根据id查询出这个菜品的基本数据
        Dish dish = this.getById(id);

        //创建一个DishDto对象，将dish里面的数据复制到这个对象中
        DishDto dishDto = new DishDto();

        BeanUtils.copyProperties(dish, dishDto);

        //根据菜品id查询菜品口味
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.eq(DishFlavor::getDishId,id);

        List<DishFlavor> list = dishFlavorService.list(queryWrapper);

        //设置dishDto的菜品口味
        dishDto.setFlavors(list);

        return dishDto;

    }

    /**
     * 定制更新，可以通过更新菜品和菜品口味
     * @param dishDto
     */
    @Transactional
    @Override
    public void updateWithFlavor(DishDto dishDto){
        //创建一个dish对象并拷贝dishDto中的数据，用来修改菜品表

        Dish dish = new Dish();
        BeanUtils.copyProperties(dishDto,dish);
        //修改菜品表

        //根据菜品id更新菜品信息
        //这里的菜品id是由回显数据的controller返回到前端，并保存在ruleForm的id中，在通过前端传给修改的controller
        this.updateById(dish);

        //获取菜品id
        Long dishId = dishDto.getId();



        //修改菜品口味表
        //先根据菜品id把对应的菜品口味全删了

        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.eq(DishFlavor::getDishId,dishId);

        boolean b = dishFlavorService.remove(queryWrapper);
        //System.out.println(b);

        //获取新的菜品口味
        List<DishFlavor> flavors = dishDto.getFlavors();

        //这里封装的菜品口味里是没有dishId的，因此要通过dishDto中的id进行封装
        for(DishFlavor flavor : flavors){
            flavor.setDishId(dishId);
        }

        //再重新添加新的菜品口味
        dishFlavorService.saveBatch(flavors);

    }

    /**
     * 定制删除，同时删除菜品和菜品口味，且单一删除和批量删除均可
     * @param ids
     */
    @Transactional
    @Override
    public void deleteWithFlavor(List<String> ids) {

        //根据id删除菜品表
        this.removeByIds(ids);

        //根据id删除菜品口味
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.in(DishFlavor::getDishId,ids);

        dishFlavorService.remove(queryWrapper);

    }

    //废弃删除代码，逻辑是在售的不删
//    @Transactional
//    @Override
//    public String deleteWithFlavor(List<String> ids) {
//
//        //这里理解错了，并不是在售就不能删。实际逻辑是先将status改为0，再删除。
//        //List<String> idsNotDelete = new ArrayList<>();
//        String idsNotDelete = "";
//        //判断商品是否在售，如果在售则不能删除
//        for(String id : ids){
//            Dish dish = this.getById(id);
//            if(dish.getStatus() == 1){
//                log.error(dish.getName() + "商品在售，删除失败");
//                ids.remove(id);
//                idsNotDelete = idsNotDelete + dish.getName() + " ";
//            }
//        }
//
//        //根据id删除菜品表
//        this.removeByIds(ids);
//
//        //根据id删除菜品口味
//        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
//
//        queryWrapper.in(DishFlavor::getDishId,ids);
//
//        dishFlavorService.remove(queryWrapper);
//
//        if(idsNotDelete.equals("")){
//            return "删除成功";
//        }else{
//            return idsNotDelete + "在售，删除失败，其余删除成功";
//        }
//
//
//    }



    //废弃删除代码
//    @Transactional
//    @Override
//    public void deleteWithFlavor(List<String> ids) {
//
//        //下面这些代码也作废了，因为可以直接传ids的集合了。本来以为只能传字符串
//
//        //由于获得ids字符串，其形式是 id,id,id
//        //因此需要将这个ids根据,拆分成多个id，并放到集合中
//        List<Long> idList = new ArrayList<>();
//
//        for(String id : ids.split(",")){
//            idList.add(Long.valueOf(id));
//        }
//        //如果只有一个id，实际效果就是将这个id放到idList中
//
//        //这里可以看出mybatisplus传入的id可以是Long类型，也可以是String类型，推测里面会自动转换？
//
//        //根据id删除菜品
//        this.removeByIds(ids);
//
//        //根据id删除菜品口味
//        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
//
//        queryWrapper.in(DishFlavor::getDishId,ids);
//
//        dishFlavorService.remove(queryWrapper);
//
//        //下面这个代码废弃了，因为前端无论是单一id，还是ids都是字符串
//
//        //如果此时传入的是ids字符串，则说明是批量删除
//        if(ids instanceof String){
//            String ids1 = (String) ids;
//
//            //由于获得ids字符串，其形式是 id,id,id
//            //因此需要将这个ids根据,拆分成多个id，并放到集合中
//            List<Long> idList = new ArrayList<>();
//
//            for(String id : ids1.split(",")){
//                idList.add(Long.valueOf(id));
//            }
//            //删除菜品表
//            this.removeByIds(idList);
//
//            LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
//
//            queryWrapper.in(DishFlavor::getDishId,idList);
//
//            dishFlavorService.remove(queryWrapper);
//
//        }
//        //如果传入的是一个Long型数据，则只是单个删除
//        else if(ids instanceof Long){
//            Long id = (Long) ids;
//
//            //根据菜品id删除菜品表
//            this.removeById(id);
//
//            //根据菜品id删除对应的菜品口味
//
//            LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
//
//            queryWrapper.eq(DishFlavor::getDishId,id);
//
//            dishFlavorService.remove(queryWrapper);
//        }
//
//    }
}
